const db = require('../models');
const EntityInstance = db.EntityInstance;

// 创建新的实体实例
exports.createEntityInstance = async (req, res) => {
    try {
        const { id, text, document_id, entity_id, isChecked } = req.body;

        // 验证必填字段
        if (!id || !text || !document_id || !entity_id) {
            return res.status(400).json({
                code: 400,
                message: '实体实例创建失败，缺少必要字段'
            });
        }

        // 创建实体实例记录
        const entityInstance = await EntityInstance.create({
            id: id,
            text: text,
            document_id: document_id,
            entity_id: entity_id,
            is_checked: isChecked || true
        });

        return res.status(200).json({
            code: 200,
            message: '实体实例创建成功',
            data: entityInstance
        });
    } catch (error) {
        console.error('创建实体实例时出错:', error);
        return res.status(500).json({
            code: 500,
            message: '创建实体实例失败，服务器错误',
            error: error.message
        });
    }
};

// 获取指定文档的所有实体实例
exports.getEntityInstances = async (req, res) => {
    try {
        const documentId = req.params.documentId;

        if (!documentId) {
            return res.status(400).json({
                code: 400,
                message: '获取实体实例失败，缺少文档ID'
            });
        }

        // 查询数据库
        const instances = await EntityInstance.findAll({
            where: { document_id: documentId }
        });

        return res.status(200).json({
            code: 200,
            message: '获取实体实例成功',
            data: instances
        });
    } catch (error) {
        console.error('获取实体实例时出错:', error);
        return res.status(500).json({
            code: 500,
            message: '获取实体实例失败，服务器错误',
            error: error.message
        });
    }
};

// 更新实体实例
exports.updateEntityInstance = async (req, res) => {
    try {
        const { id, text, document_id, entity_id, isChecked } = req.body;

        if (!id) {
            return res.status(400).json({
                code: 400,
                message: '更新实体实例失败，缺少实体实例ID'
            });
        }

        // 查找实体实例
        const instance = await EntityInstance.findByPk(id);

        if (!instance) {
            return res.status(404).json({
                code: 404,
                message: '实体实例不存在'
            });
        }

        // 更新实体实例
        await instance.update({
            text: text || instance.text,
            document_id: document_id || instance.document_id,
            entity_id: entity_id || instance.entity_id,
            is_checked: isChecked !== undefined ? isChecked : instance.is_checked
        });

        return res.status(200).json({
            code: 200,
            message: '实体实例更新成功',
            data: instance
        });
    } catch (error) {
        console.error('更新实体实例时出错:', error);
        return res.status(500).json({
            code: 500,
            message: '更新实体实例失败，服务器错误',
            error: error.message
        });
    }
};

// 删除单个实体实例
exports.deleteEntityInstance = async (req, res) => {
    try {
        const { instanceId } = req.body;

        if (!instanceId) {
            return res.status(400).json({
                code: 400,
                message: '删除实体实例失败，缺少实体实例ID'
            });
        }

        // 查找实体实例
        const instance = await EntityInstance.findByPk(instanceId);

        if (!instance) {
            return res.status(404).json({
                code: 404,
                message: '实体实例不存在'
            });
        }

        // 删除实体实例
        await instance.destroy();

        return res.status(200).json({
            code: 200,
            message: '实体实例删除成功'
        });
    } catch (error) {
        console.error('删除实体实例时出错:', error);
        return res.status(500).json({
            code: 500,
            message: '删除实体实例失败，服务器错误',
            error: error.message
        });
    }
};

// 删除指定实体类的所有实例
exports.deleteEntityInstancesByEntityId = async (req, res) => {
    try {
        const { documentId, entityId } = req.body;

        if (!documentId || !entityId) {
            return res.status(400).json({
                code: 400,
                message: '批量删除实体实例失败，缺少必要参数'
            });
        }

        // 删除所有匹配的实体实例
        const result = await EntityInstance.destroy({
            where: {
                document_id: documentId,
                entity_id: entityId
            }
        });

        return res.status(200).json({
            code: 200,
            message: `成功删除 ${result} 个实体实例`
        });
    } catch (error) {
        console.error('批量删除实体实例时出错:', error);
        return res.status(500).json({
            code: 500,
            message: '批量删除实体实例失败，服务器错误',
            error: error.message
        });
    }
}; 